package com.example.map;

import org.junit.Test;

import java.util.*;

/**
 * @author readpage
 * @create 2022-09-26 19:36
 *
 * |----Map:双列数据，存储key-value对的数据
 *      |----HashMap:作为Map的主要实现类: 线程不安全，效率高；存储null的key和value
 *           |----LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序来实现遍历。
 *                  原因: 在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。
 *                  对于频繁的遍历操作，此类执行效率高于HashMap。
 *      |----TreeMap: 保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序
 *                    底层使用红黑树
 *      |----Hashtable:作为古老的实现类;线程安全，效率低;不能存储null的key和value
 *           |----Properties: 常用来处理配置文件。key和value都是String类型
 *
 *      HashMap的底层: 数组+链表 (jdek7及之前)
 *                    数组+链表+红黑树 (jdk 8)
 *  二、Map结构的理解:
 *      Map中的key:无序的、不可重复的，使用重复的，使用Set存储所有的key ---> key所在的类要重写equals()和hashCode()
 *      Map中的value:无序的、可重复的，使用Collection存储所有的value ---> value所在的类要重写equals()
 *      一个键值对:key-value构成了一个Entry对象。
 *      Map中的entry:无序的、不可重复的，使用Set存储所有的entry
 *
 *  三、HashMap的底层实现原理? 以jdk7为例说明:
 *     HashMap map = new HashMap():
 *      在实例化以后，底层创建了长度是16的一维数组Entry[] table。
 *      ...可能已经执行过多次put
 *      map.put(key1,value1):
 *      首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置
 *      如果此位置上的数据为空，此时的key1-value1添加成功。 ---情况1
 *      如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已存在的一个或多个数据
 *      的哈希值:
 *              如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。 ---情况2
 *              如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较: 调用key1所在类的equals(key2)方法
 *              如果equals()返回false:此时key1-value1添加成功。
 *              如果equals()返回true:使用value1替换相同key的value2。 ---情况3
 *         补充: 关于情况2和情况3: 此时key1-value1和原来的数据以链表的方式存储。
 *
 *         在不断的添加过程中，会涉及到扩容问题，默认的扩容方式: 扩容为原来容易的2倍，并将原有的数据复制过来
 *
 *         jdk8 相较于jdk7在底层实现方面的不同:
 *         1. new hashMap():底层没有创建一个长度为16的数组
 *         2. jdk 8底层的数组是: Node[],而非Entry[]
 *         3. 首次调用put()方法时，底层创建长度为16的数组
 *         4. jdk7底层结构只有: 数组+链表。jdk8中底层结构: 数组+链表+红黑数。
 *            当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时索引位置上的所有数据改为使用红黑树存储。
 */
public class MapTest {
    /**
     * 添加、删除、修改操作:
     * Object put(Object key, Object value): 将指定key-value添加到(或修改)当前map对象中
     * void putAll(Map m): 将m中的所有key-value对存放到当前map中
     * Object remove(Object key): 移除指定key的key-value对，并返回value
     * void clear(): 清空当前map中的所有数据
     */
    @Test
    public void test() {
        Map<Object, Object> map = new HashMap<>();
        map.put("AA", 123);
        map.put(45, 123);
        map.put("BB", 56);
        map.put("AA", 87);
        System.out.println(map);

        Map<Object, Object> map2 = new HashMap<>();
        map2.put("CC", 123);
        map2.put("DD", 123);
        map.putAll(map2);
        System.out.println(map);

        System.out.println("------------");
        // remove(Object key)
        Object value = map.remove("CC");
        System.out.println(value);
        System.out.println(map);

        //clear()
        map.clear(); // 于map = null 操作不同
        System.out.println(map.size());
        System.out.println(map);
    }

    /**
     * 元素查询的操作
     * Object get(Object key): 获取指定key对应的value
     * boolean containsKey(Object key): 是否包含指定的key
     * boolean containsValue(Object value): 是否包含指定的value
     * int size(): 返回map中key-value对的个数
     * boolean isEmpty(): 判断当前map是否为空
     * boolean equals(Object obj): 判断当前map和参数对象obj是否相等
     */
    @Test
    public void test2() {
        Map<Object, Object> map = new HashMap<>();
        map.put("AA", 123);
        map.put(45, 123);
        map.put("BB", 56);

        // Object get(Object key)
        System.out.println(map.get(45));
        
        //boolean containsKey(Object key)
        boolean isExist = map.containsKey("BB");
        System.out.println(isExist);

        //boolean containsValue(Object value)
        isExist = map.containsValue(123);
        System.out.println(isExist);

        map.clear();
        // boolean isEmpty()
        System.out.println(map.isEmpty());
    }

    /**
     * 元试图操作的方法
     * Set keySet(): 返回所有key构成的Set集合
     * Collection values(): 返回所有value构成的Collection集合
     * Set entrySet(): 返回所有key-value对构成的Set集合
     */
    @Test
    public void test3() {
        Map<Object, Object> map = new HashMap<>();
        map.put("AA", 123);
        map.put(45, 123);
        map.put("BB", 56);

        //遍历所有的key集: keySet()
        Set<Object> set = map.keySet();
        Iterator<Object> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        //遍历所有value的集: values()
        Collection<Object> values = map.values();
        for(Object obj: values) {
            System.out.println(values);
        }

        //遍历所有的key-value
        // entrySet
        Set<Map.Entry<Object, Object>> entries = map.entrySet();
        Iterator<Map.Entry<Object, Object>> iterator2 = entries.iterator();
        while (iterator2.hasNext()) {
            Map.Entry<Object, Object> entry = iterator2.next();
            System.out.println(entry.getKey() + "---->" + entry.getValue());
        }
        System.out.println();

        // 方式2
        Set<Object> set2 = map.keySet();
        Iterator<Object> iterator3 = set.iterator();
        while (iterator3.hasNext()) {
            Object key = iterator3.next();
            Object value = map.get(key);
            System.out.println(key + "====" + value);
        }
    }

    @Test
    public void test4() {
        Map<Object, Object> map = new HashMap<>();
        map.put(null, 123);
        map = new Hashtable<>();
        map.put(null, null);
    }

    @Test
    public void test5() {
        System.out.println(String.format("%.2f", 0.0 * 100));
    }
}
